package com.mayisoftware.mayioa.business.worktime.impl.task;

import com.mayisoftware.mayioa.business.worktime.api.common.TMWorktimeConstants;
import com.mayisoftware.mayioa.business.worktime.api.domain.TMWorkTimeFileInfo;
import com.mayisoftware.mayioa.business.worktime.api.domain.WrokTimeImportInfo;
import com.mayisoftware.mayioa.business.worktime.api.service.ITMWorkTimeLieService;
import com.mayisoftware.mayioa.business.worktime.api.service.IWorkTimeService;
import com.mayisoftware.mayioa.common.impl.utils.file.FileUtils;
import com.mayisoftware.mayioa.common.impl.zip.FileUnZipRar;
import com.mayisoftware.mayioa.common.impl.zip.UnZipFile;
import com.mayisoftware.mayioa.platform.api.service.*;
import org.apache.commons.collections4.CollectionUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.io.*;
import java.util.*;

/**
 * 定时任务调度计划解析
 *
 *
 */
@Component("tmFileParseTask")
public class TMFileParseTask
{
    /**
     * 日志对象
     */
    private static final Logger log = LoggerFactory.getLogger(TMFileParseTask.class);

    /**
     * 上传记录操作服务
     */
    @Autowired
    private ITMWorkTimeLieService checkService;
    /**
     * 上传记录操作服务
     */
    @Autowired
    private IWorkTimeService uploadRecordService;

    /**
     * 用户管理服务
     */
    @Autowired
    private ISysUserService sysUserService;

    public void parseTMFiles()
    {
        log.info("开始执行工时文件解析");

        try {
            //查询数据库记录
            List<WrokTimeImportInfo> uploadRecords = uploadRecordService.queryRecordListNeedParse();

            if(CollectionUtils.isEmpty(uploadRecords)){
//                log.warn("没有需要解析的工时文件");
                return;
            }

            String errorFilePath = "";
            for (WrokTimeImportInfo record:uploadRecords){
                boolean isOk = true;
                WrokTimeImportInfo updateRecord = new WrokTimeImportInfo();
                try {
                    log.info("处理记录 id: {} 文件:{}",record.getImportId(),record.getFilePath());
                    String filePath = record.getFilePath();

                    File file =new File(filePath);
                    if(!file.exists() || !file.isFile()){
                        log.error("处理记录 id: {} 文件:{}不存在",record.getImportId(),record.getFilePath());
                        continue;
                    }

                    String fileName= file.getName();
                    String fileDir=file.getParentFile().getAbsolutePath();
                    String fileNameNoExt = fileName.substring(0,fileName.lastIndexOf("."));
                    errorFilePath = fileDir+File.separator+fileNameNoExt+".log";

                    updateRecord.setImportId(record.getImportId());
                    //更新DB状态 正在解析
                    updateRecord.setParseStatus("2");

                    uploadRecordService.editInputRecord(updateRecord);
                    fileDir+=File.separator+fileNameNoExt;
                    StringBuffer planBuffer =new StringBuffer();
                    isOk = dealOneUploadFile(record,file,errorFilePath,fileDir,planBuffer );
                }
                catch (Exception e){
                    log.error("处理记录 id: {} 文件:{},异常",record.getImportId(),record.getFilePath(),e);
                }
                finally {
                    try {
                        if (isOk){
                            log.info("处理记录 id: {} 文件:{},处理成功",record.getImportId(),record.getFilePath());
                            //更新DB状态 正在解析

                            updateRecord.setParseStatus("3");
                            uploadRecordService.editInputRecord(updateRecord);
                        }
                        else {
                            log.info("处理记录 id: {} 文件:{},处理失败",record.getImportId(),record.getFilePath());
                            //更新DB状态 正在解析
                            updateRecord.setParseStatus("4");
                            updateRecord.setErrorPath(errorFilePath);
                            uploadRecordService.editInputRecord(updateRecord);
                        }
                    }
                    catch (Exception e){
                        log.info("处理记录状态异常",e);
                    }
                }
            }
        } catch (Exception e) {
            log.error("执行计划解析异常",e);
        }
    }

    /**
     * 处理一个上传记录文件
     */
    private boolean dealOneUploadFile(WrokTimeImportInfo record, File file,String  errorFilePath, String dstDirectoryPath,StringBuffer planBuffer) {

        String filePath = file.getAbsolutePath();
        String unzipDir = "";

        FileUtils.writeLog(errorFilePath,"解压缩文件："+filePath);
        try {
            if (filePath.toLowerCase().endsWith(".rar")) {
                FileUnZipRar.unRarFile(filePath, dstDirectoryPath);
                unzipDir = dstDirectoryPath;
            } else if (filePath.toLowerCase().endsWith(".zip")) {
                unzipDir = UnZipFile.unZipFile(file, dstDirectoryPath);
            }else{
                File sourceFile = new File(filePath);
                File destFile = new File(dstDirectoryPath+File.separator+sourceFile.getName());
                FileUtils.copyFile(sourceFile,destFile);
                unzipDir = dstDirectoryPath;
            }
        }catch (Exception ex){
            FileUtils.writeLog(errorFilePath,"解压缩文件发生异常！"+ex.getMessage());
            log.error("解压缩文件发生异常！"+ex.getMessage());
            return false;
        }

        return analysisOneWorkTimeFile(unzipDir,errorFilePath);
    }

    /**
     * 统计分析主方法
     * @param tmPath TM文件路径
     * @return 0：成功，-1：失败
     */
    private   boolean analysisOneWorkTimeFile(String tmPath,String errorFilePath){
        FileUtils.writeLog(errorFilePath,"解析目录中："+tmPath);
        File path = new File(tmPath);
        //1.TM项目考勤读取
        if (!path.isDirectory()){
            log.error("处理记录 文件:{},不存在！",tmPath);
            return false;
        }

        List<File> files = FileUtils.getExcelFileList(tmPath);
        List<TMWorkTimeFileInfo> detailFiles = new ArrayList<>();
        for (File file:files) {
            FileUtils.writeLog(errorFilePath,"获取到文件："+file.getAbsolutePath());
            TMWorkTimeFileInfo tmFileInfo = new TMWorkTimeFileInfo();
            String filename = file.getName();
            List<String> items = Arrays.asList(filename.split("_"));

            if (filename.contains("详单")) {
                tmFileInfo.setFileType(TMWorktimeConstants.TM_FILE_TYPE.DETAIL);
            }else if(filename.contains("月结")){
                tmFileInfo.setFileType(TMWorktimeConstants.TM_FILE_TYPE.MONTH);
            }else{
                FileUtils.writeLog(errorFilePath,"TM考勤文件："+file.getAbsoluteFile()+"，不是详单文件，自动跳过。");
                log.error("TM考勤文件："+file.getAbsoluteFile()+"，不是详单文件，自动跳过。");
                continue;
            }

            if (items.size()<6) {
                FileUtils.writeLog(errorFilePath,"TM考勤文件："+file.getAbsoluteFile()+"，文件名无效。");
                log.error("TM考勤文件："+file.getAbsoluteFile()+"，文件名无效。");
                continue;
            }
            tmFileInfo.setMonth(items.get(0));
            tmFileInfo.setRegion(items.get(2));
            tmFileInfo.setBg(items.get(3));
            tmFileInfo.setBu(items.get(4));
            tmFileInfo.setPdu(items.get(5));
            tmFileInfo.setPoNum(getPoNum(items.get(6)));
            tmFileInfo.setFileName(file.getAbsolutePath());
            detailFiles.add(tmFileInfo);
        }

        if (detailFiles.size()==0){
            FileUtils.writeLog(errorFilePath,"TM考勤目录无有效详单文件："+tmPath);
            log.error("TM考勤目录{}无有效详单文件。。。！",tmPath);
            return false;
        }

        if (!checkService.check(detailFiles,errorFilePath)){
            FileUtils.writeLog(errorFilePath,"TM考勤文件导入失败。。。");
            log.error("TM考勤文件导入失败。。。");
            return false;
        }
        FileUtils.writeLog(errorFilePath,"TM考勤文件导入成功。");

        return  true;
    }

    private String getPoNum(String poString){
        //97-122，A-Z：65-90，0-9：48-57
        String retString = "";
        for (char c:poString.toCharArray()) {
            if ((c>=97&&c<=122)||(c>=65&&c<=90)||(c>=48&&c<=57)){
                retString+=c;
            }else {
                break;
            }
        }

        return retString;
    }
    /**
     * 检查字典中是否含有该类型
     */
//    private String checkDictData(String dictType,String cellValue){
//        List<SysDictData> sysDictDataList = sysDictDataService.selectDictDataByType(dictType);
//
//        if (!StringUtils.isEmpty(cellValue)) {
//            for (SysDictData data : sysDictDataList) {
//                if (data.getDictLabel().equalsIgnoreCase(cellValue)) {
//                    return data.getDictValue();
//                }
//            }
//
//            return  "";
//        }
//        return "NULL_STR_NOT_CHECK";
//    }


    /**
     * 分析每一行单元格
     */
//    private boolean analysisCells(WrokTimeImportInfo record,Map<Integer,String>  cells, boolean isFirst,int rowNum,String sheetName,
//                               Map<String,Integer> col_pos,BufferedWriter bufferedWriter ,PlanConfig planConfig,
//                               Map<String ,PlanDetailConfig> planDetailName_Config, Map<String,BigDecimal> ach_values ) throws IOException {
//
//        if (isFirst){
//           return true;
//        }
//        boolean hasError = false;
//        boolean isUserExists = false;
//        Long curUserId = -1L;
//        SysUser sheetUser = new SysUser();
//        SysUser user = null;
//        Integer sheetUserIdPos = col_pos.get("工号");
//        if (sheetUserIdPos == null){
//            bufferedWriter.write(rowNum+"行没有配置工号,或者数据无效");
//            bufferedWriter.newLine();
//            hasError = true;
//        }
//        else {
//            String userId = cells.get(sheetUserIdPos);
//
//            if (StringUtils.isEmpty(userId)) {
//                bufferedWriter.write(rowNum + "行没有配置工号或者数据无效");
//                bufferedWriter.newLine();
//                hasError = true;
//            }
//            else {
//                //检查用户是否存在
//                try {
//                    curUserId=Long.parseLong(userId);
//                    sheetUser.setUserId(curUserId);
//                    user = sysUserService.selectUserById(curUserId);
//
//                    if (user == null) {
////                        bufferedWriter.write(rowNum + "行工号无效");
////                        bufferedWriter.newLine();
////                        hasError = true;
//                        isUserExists =false;
//                    }else {
//                        isUserExists =true;
//                    }
//                }
//                //工号必须是数字
//                catch (Exception e) {
//                    bufferedWriter.write(rowNum + "行没有配置工号或者数据无效");
//                    bufferedWriter.newLine();
//                    hasError = true;
//                }
//            }
//        }
//
//        String userName = getValueByKey("姓名",cells, col_pos);
//        if (!StringUtils.isEmpty(userName)){
//            sheetUser.setUserName(userName);
//        }
//
//        String userEmail = getValueByKey("邮箱",cells, col_pos);
//        if (!StringUtils.isEmpty(userEmail)){
//            if (CommonCheckUtil.emailFormat(userEmail)){
//                sheetUser.setEmail(userEmail);
//            }
//            else {
//                bufferedWriter.write(rowNum+"行邮箱格式不正确.");
//                bufferedWriter.newLine();
//                hasError = true;
//            }
//        }
//
//        String userTelephone = getValueByKey("电话",cells, col_pos);
//        if (!StringUtils.isEmpty(userTelephone)){
//            if(CommonCheckUtil.isNumeric(userTelephone)){
//                sheetUser.setPhonenumber(userTelephone);
//            }
//            else {
//                bufferedWriter.write(rowNum+"行电话格式不正确.");
//                bufferedWriter.newLine();
//                hasError = true;
//            }
//        }
//
//        String userProjectRole  = getValueByKey("项目组角色",cells, col_pos);
//        String userProjectRoleValue = checkDictData("sys_user_project_role",userProjectRole);
//        if (userProjectRoleValue.isEmpty()){
//            bufferedWriter.write(rowNum+"行项目组角色错误或未在数据字典中配置.");
//            bufferedWriter.newLine();
//            hasError = true;
//        }
//        else if (!userProjectRoleValue.equalsIgnoreCase(InputConstants.NULL_STR_NOT_CHECK)){
//            sheetUser.setProjectRole(userProjectRoleValue);
//        }
//
//        String userArea  = getValueByKey("地区",cells, col_pos);
//        String userAreaValue = checkDictData("sys_user_region",userArea);
//        if (userAreaValue.isEmpty()){
//            bufferedWriter.write(rowNum+"行地区错误或未在数据字典中配置.");
//            bufferedWriter.newLine();
//            hasError = true;
//        }
//        else if (!userAreaValue.equalsIgnoreCase(InputConstants.NULL_STR_NOT_CHECK)){
//            sheetUser.setRegion(userAreaValue);
//        }
//
//        String userParent = getValueByKey("直接上级",cells, col_pos);
//        if (!StringUtils.isEmpty(userParent)){
//            try{
//                sheetUser.setDirectSuperiorUserId(Long.parseLong(userParent));
//            }
//            catch (Exception e){
//                log.error("直接上级格式不正确",e);
//                bufferedWriter.write(rowNum+"行部直接上级格式不对.");
//                bufferedWriter.newLine();
//                hasError = true;
//            }
//        }
//
//        String deptName = getValueByKey("成本中心",cells, col_pos);
//
//        if(!StringUtils.isEmpty(deptName)){
//            List<SysDept> sysDepts = deptService.selectDeptList(new SysDept());
//
//            boolean bhave=false;
//            for (SysDept dept:sysDepts){
//                if (dept.getDeptName() != null && deptName !=null && dept.getDeptName().equalsIgnoreCase(deptName)){
//                    bhave = true;
//                    sheetUser.setDeptId(dept.getDeptId());
//                    break;
//                }
//            }
//
//            if (!bhave){
//                bufferedWriter.write(rowNum+"行部门名称没有在系统中配置.");
//                bufferedWriter.newLine();
//                hasError = true;
//            }
//        }
//
//        String sex  = getValueByKey("性别",cells, col_pos);
//        String sexValue = checkDictData("sys_user_sex",sex);
//        if (sexValue.isEmpty()){
//            bufferedWriter.write(rowNum+"行性别配置错误.");
//            bufferedWriter.newLine();
//            hasError = true;
//        }
//        else if (!sexValue.equalsIgnoreCase(InputConstants.NULL_STR_NOT_CHECK)){
//            sheetUser.setSex(sexValue);
//        }
//
//        String hwLevel  = getValueByKey("华为职级",cells, col_pos);
//        String hwLevelValue = checkDictData("sys_hw_level",hwLevel);
//        if(hwLevelValue.isEmpty()){
//            bufferedWriter.write(rowNum+"行华为级别配置错误，或者该级别未在系统中配置.");
//            bufferedWriter.newLine();
//            hasError = true;
//        }if (!hwLevelValue.equalsIgnoreCase(InputConstants.NULL_STR_NOT_CHECK)){
//            sheetUser.setHwLevel(hwLevelValue);
//        }
//
//        String post  = getValueByKey("蚂蚁职位",cells, col_pos);
//
//        List<Long> postIds = new ArrayList<>();
//        if (!StringUtils.isEmpty(post)){
//            List<SysPost> sysPosts = sysPostService.selectPostAll();
//            boolean have =false;
//            for (SysPost sysPost:sysPosts){
//                if (sysPost.getPostName().equalsIgnoreCase(post)){
//                    postIds.add(sysPost.getPostId());
//                    have =true;
//                }
//            }
//
//            if (!have){
//                bufferedWriter.write(rowNum+"行蚂蚁职位配置错误，或者该级别未在系统中配置.");
//                bufferedWriter.newLine();
//                hasError = true;
//            }
//            else {
//                sheetUser.setPostIds(postIds.toArray(new Long[postIds.size()]));
//            }
//        }
//
//        String coopMode  = getValueByKey("合作模式",cells, col_pos);
//        String coopModeValue = checkDictData("sys_coop_model",coopMode);
//        if(coopModeValue.isEmpty()){
//            bufferedWriter.write(rowNum+"行合作模式配置错误，或者该合作模式未在系统中配置.");
//            bufferedWriter.newLine();
//            hasError = true;
//        }else if (!coopModeValue.equalsIgnoreCase(InputConstants.NULL_STR_NOT_CHECK)){
//            sheetUser.setCoopModel(coopModeValue);
//        }
//
//        String joinTime  = getValueByKey("入职日期",cells, col_pos);
//        if (!StringUtils.isEmpty(joinTime)){
//            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
//            try {
//                Date dt =sdf.parse(joinTime);
//                sheetUser.setJoinTime(dt);
//            }
//            catch (Exception e)
//            {
//                bufferedWriter.write(rowNum+"行入职日期配置格式错误.");
//                bufferedWriter.newLine();
//                hasError = true;
//            }
//        }
//
//        String workTime  = getValueByKey("工作日期",cells, col_pos);
//        if (!StringUtils.isEmpty(workTime)){
//            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
//            try {
//                Date dt= sdf.parse(workTime);
//                sheetUser.setWorkTime(dt);
//            }
//            catch (Exception e)
//            {
//                bufferedWriter.write(rowNum+"行工作日期配置格式错误.");
//                bufferedWriter.newLine();
//                hasError = true;
//            }
//        }
//
//        String universe  = getValueByKey("毕业院校",cells, col_pos);
//
//        if (!StringUtils.isEmpty(universe)){
//            sheetUser.setSchool(universe);
//        }
//
//        String education  = getValueByKey("学历",cells, col_pos);
//
//        if (!StringUtils.isEmpty(education)){
//            sheetUser.setEducation(education);
//        }
//
//        String is211  = getValueByKey("是否211",cells, col_pos);
//        String is211Value = checkDictData("sys_school_211",is211);
//        if(is211Value.isEmpty()){
//            bufferedWriter.write(rowNum+"行是否211配置错误，或者未在系统中配置.");
//            bufferedWriter.newLine();
//            hasError = true;
//        }
//        else if (!is211Value.equalsIgnoreCase(InputConstants.NULL_STR_NOT_CHECK)){
//            sheetUser.setIs211(is211Value);
//        }
//
//        List<ScoreInfo> scoreInfos = new ArrayList<>();
//        for (Map.Entry<String,Integer> colposEntry: col_pos.entrySet()){
//            String colName = colposEntry.getKey();
//            Integer colPos = colposEntry.getValue();
//            //检查绩效是否配置
//
//            String achName = "";
//            String achValue = "";
//            String type = "";
//            if (colName.startsWith("绩效\n") )
//            {
//                type = "3";
//            }
//
//            if (colName.startsWith("课程\n") )
//            {
//                type = "1";
//            }
//
//            if (colName.startsWith("自定义\n") )
//            {
//                type = "2";
//            }
//
//            if (!type.isEmpty()){
//                String [] achValues = colName.split("\n");
//                if (achValues.length != 3){
//                    bufferedWriter.write(rowNum+"行"+colName+"格式配置错误.");
//                    bufferedWriter.newLine();
//                    hasError = true;
//                    continue;
//                }
//
//                //绩效名称
//                 achName = achValues[1];
//                //绩效字典类型为3
//                if (!planDetailName_Config.containsKey(type+"_"+achName)){
//                    bufferedWriter.write(rowNum+"行"+colName+" 计划没有配置该考核项目.");
//                    bufferedWriter.newLine();
//                    hasError = true;
//                    continue;
//                }
//
//                achValue  = getValueByPos(colPos, cells);
//                BigDecimal numAchValue =null;
//
//                if (achValue != null && !achValue.isEmpty()){
//                    try {
//                        if (type.equalsIgnoreCase("3")){
//                            BigDecimal decVal= ach_values.get(achValue);
//                            if (decVal == null){
//                                throw  new Exception("绩效值无效");
//                            }
//                            numAchValue = decVal;
//                        }
//                        else {
//                            numAchValue= new BigDecimal(achValue);
//                        }
//                    }
//                    catch (Exception e){
//                        bufferedWriter.write(rowNum+"行"+colName+" 考核项目值不是数字或者无效.");
//                        bufferedWriter.newLine();
//                        hasError = true;
//                        continue;
//                    }
//                    //根据名称读取绩效的配置信息
//                    PlanDetailConfig planAchievementCfg = planDetailName_Config.get(type+"_"+achName);
//                    ScoreInfo scoreInfo = new ScoreInfo();
//                    scoreInfo.setScoreUserId(curUserId.intValue());
//                    scoreInfo.setScoreUpdateTime(new Date());
//                    scoreInfo.setScoreUpdateUserId(record.getRecordUserId());
//                    scoreInfo.setScoreInfo(numAchValue);
//                    scoreInfo.setScorePlanId(planConfig.getPlanCfgId());
//                    scoreInfo.setScorePlanItemId(planAchievementCfg.getPlanCfgItemRecordid());
//                    scoreInfo.setExists(false);
//                    if (isUserExists ){
//                         List<ScoreInfo> infos =  scoreInfoService.selectScoreInfoListByUserAndPlan(scoreInfo);
//                         if (CollectionUtils.isEmpty(infos)){
//                             scoreInfo.setExists(false);
//                         }
//                         else {
//                             scoreInfo.setExists(true);
//                             scoreInfo.setScoreRecordId(infos.get(0).getScoreRecordId());
//                         }
//                    }
//                    scoreInfos.add(scoreInfo);
//                }
//            }
//        }
//
//        if (hasError || CollectionUtils.isEmpty(scoreInfos)){
//            return false;
//        }
//
//        //刷新用户信息
//        //刷新打分信息
//        updateUserAndScoreInfo(planConfig,isUserExists,sheetUser,scoreInfos);
//
//        return  true;
//
//    }
//
//    /**
//     *刷新用户状态和用户打分信息
//     */
//    private void updateUserAndScoreInfo(PlanConfig planConfig,boolean isUserExists, SysUser sheetUser, List<ScoreInfo> scoreInfos) {
//        if (isUserExists){
//            sysUserService.updateUserInfo(sheetUser);
//        }
//        else {
//            SysUser tmpUser= sysUserService.selectUserById(sheetUser.getUserId());
//            if (tmpUser == null){
//                sheetUser.setLoginName(sheetUser.getUserName()+sheetUser.getUserId());
//                Long [] roles = new Long[1];
//                roles[0] = 2L;
//                sheetUser.setRoleIds(roles);
//                sheetUser.setSalt(ShiroUtils.randomSalt());
//
//                String defaultPass = sysConfigService.selectConfigByKey("sys.user.initPassword");
//                sheetUser.setPassword(defaultPass);
//                sheetUser.setPassword(passwordService.encryptPassword(sheetUser.getLoginName(), defaultPass, sheetUser.getSalt()));
//                sysUserService.insertUser(sheetUser);
//            }
//            else {
//                sysUserService.updateUserInfo(sheetUser);
//            }
//        }
//
//        for (ScoreInfo scoreInfo:scoreInfos){
//            if(scoreInfo.getExists()){
//                scoreInfoService.updateByPrimaryKeySelective(scoreInfo);
//            }
//            else {0
//
//                scoreInfoService.insertOneScoInfo(scoreInfo);
//            }
//        }
//
//        //刷新报名信息
//        List<PersonalSign> personalSigns =personSignService.querySignListByUserId(sheetUser.getUserId().intValue());
//
//        boolean bhave =false;
//        if (CollectionUtils.isEmpty(personalSigns)){
//             bhave =false;
//        }
//        else {
//            for (PersonalSign personalSign: personalSigns){
//                if (personalSign.getPerSignPlanId().equals(planConfig.getPlanCfgId().intValue())){
//                    bhave =true;
//                    break;
//                }
//            }
//        }
//
//        if (!bhave){
//            PersonalSign personalSign = new PersonalSign();
//            personalSign.setPerSignUserId(sheetUser.getUserId().intValue());
//            personalSign.setPerSignUpdateTime(new Date());
//            personalSign.setPerSignPlanId(planConfig.getPlanCfgId());
//            personalSign.setResult("1");
//            personSignService.addSignInfo(personalSign);
//        }
//        else {
//            PoolMgrInfo mgrInfo = new PoolMgrInfo();
//            mgrInfo.setPoolUpdateTime(new Date());
//            mgrInfo.setPoolUserId(sheetUser.getUserId().intValue());
//            mgrInfo.setPoolPlanId(planConfig.getPlanCfgId());
//            mgrInfo.setPoolScoreStatus(0);
//            poolManualService.modifyPoolInfoByUserPlan(mgrInfo);
//        }
//    }

    /**
     * 读取该键对应的列信息
     */
//    private String getValueByKey(String key,Map<Integer, String> cells, Map<String, Integer> col_pos) {
//        Integer pos = col_pos.get(key);
//        if (pos == null){
//            return null ;
//        }
//
//        String value = cells.get(pos);
//
//        if(value == null ){
//            return null;
//        }
//
//        return  value;
//    }
//
//    /**
//     * 读取该键对应的列信息
//     */
//    private String getValueByPos(Integer pos,Map<Integer, String> cells) {
//
//        String value = cells.get(pos);
//
//        if(value == null ){
//            return null;
//        }
//
//        return  value;
//    }
}
